e2e/grpc_test.go (1)

81-161: Table-drive the gRPC endpoint checks to reduce duplication.

The subtests are valid; converting them to table-driven cases would better match project test conventions and make future endpoint additions easier.

As per coding guidelines, "Use table-driven tests in Go test files".

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/grpc_test.go` around lines 81 - 161, Convert the repeated subtests into a
single table-driven test: define a slice of test cases (with fields name, call
type or a function closure, request payload, and a verify function) and iterate
with t.Run for each case; replace the separate invocations of
blobClient.GetByCommitment, blobClient.Get, blobClient.GetAll,
headerClient.GetByHeight, and headerClient.LocalHead by entries in that table,
using the existing variables (data, commitment, height, namespace) in the
request/verification closures; ensure each case's verify closure checks the same
conditions now duplicated (nil checks, data/commitment equality, blob inclusion,
header height comparisons) and call t.Fatalf/t.Fatal within the closure on
failure so behavior remains identical.

e2e/indexing_test.go (1)

69-128: Consider table-driving the RPC path assertions.

These subtests are clear, but a table-driven structure would remove repetition and match repository test conventions.

♻️ Refactor sketch

+type rpcCase struct {
+	name   string
+	method string
+	params []any
+	assert func(t *testing.T, r jsonRPCResponse)
+}
+
+cases := []rpcCase{
+	// blob.Get, blob.GetAll, header.GetByHeight, header.LocalHead
+}
+
+for _, tc := range cases {
+	tc := tc
+	t.Run(tc.name, func(t *testing.T) {
+		r := doRPC(t, proc, apexRPCAddr, tc.method, tc.params...)
+		if r.Error != nil {
+			t.Fatalf("%s error: %s", tc.name, r.Error.Message)
+		}
+		tc.assert(t, r)
+	})
+}

As per coding guidelines, "Use table-driven tests pattern for test cases".

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/indexing_test.go` around lines 69 - 128, The subtests under Test (calls
to doRPC with RPC methods
"blob.Get","blob.GetAll","header.GetByHeight","header.LocalHead" and assertions
on rpcBlob/results) repeat similar logic; convert them to a table-driven test by
creating a slice of test cases (each with name, method string, params, and a
small checker function or expected condition) and iterate with for _, tc :=
range cases { t.Run(tc.name, func(t *testing.T) { r := doRPC(..., tc.method,
tc.params...); if r.Error != nil { t.Fatalf(...) }; tc.check(t, r) }) }.
Reference the existing helpers and types (doRPC, rpcBlob, commitment, data) when
implementing each case’s checker to preserve current assertions (blob
content/commitment checks, non-null header checks, blob list contains
commitment).

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

e2e/grpc_test.go (1)

87-177: Refactor repeated subtests into a table-driven structure.

The five gRPC assertions duplicate setup/timeout scaffolding; a table-driven loop would reduce repetition and make future endpoint additions easier to maintain.

♻️ Suggested refactor shape

+testCases := []struct {
+	name string
+	run  func(t *testing.T, rpcCtx context.Context)
+}{
+	{name: "BlobService.GetByCommitment", run: func(t *testing.T, rpcCtx context.Context) { /* existing assertions */ }},
+	{name: "BlobService.Get", run: func(t *testing.T, rpcCtx context.Context) { /* existing assertions */ }},
+	{name: "BlobService.GetAll", run: func(t *testing.T, rpcCtx context.Context) { /* existing assertions */ }},
+	{name: "HeaderService.GetByHeight", run: func(t *testing.T, rpcCtx context.Context) { /* existing assertions */ }},
+	{name: "HeaderService.LocalHead", run: func(t *testing.T, rpcCtx context.Context) { /* existing assertions */ }},
+}
+
+for _, tc := range testCases {
+	tc := tc
+	t.Run(tc.name, func(t *testing.T) {
+		rpcCtx, cancel := newRPCCtx(t)
+		defer cancel()
+		tc.run(t, rpcCtx)
+	})
+}

As per coding guidelines, "Use table-driven tests pattern for test cases".

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@e2e/grpc_test.go` around lines 87 - 177, The five nearly-identical t.Run
blocks should be refactored into a single table-driven test: create a slice of
test cases (with fields like name, request, clientMethod identifier e.g.
blobClient.GetByCommitment, blobClient.Get, blobClient.GetAll,
headerClient.GetByHeight, headerClient.LocalHead, and expected-check type), then
loop over them calling t.Run(tc.name, func(t *testing.T){ rpcCtx, cancel :=
newRPCCtx(t); defer cancel(); resp, err := tc.clientMethod(rpcCtx, tc.request);
handle err and perform the appropriate assertions based on tc.expected-check
(non-nil blob/header, data/commitment equality, presence in GetAll, height
checks) so setup/teardown and timeouts are shared and new endpoints can be added
by appending to the table.